"""
1. 创建一个列表`list1`，其包含元素 1, 2, 3, 4, 5。
2. 向`list1` 添加一个元素 6。
3. 从`list1` 中删除元素 3。
4. 修改`list1` 中的第二个元素值为 8。
5. 找出`list1` 中值为 8 的元素索引。
6. 遍历`list1`，打印每个元素的值。
7. 利用循环，将一个新列表 `7, 8, 9]` 的每个元素添加到`list1` 的末尾。
8. 使用一个命令，将列表 `10, 11, 12]` 添加到`list1` 的末尾。
9. 使用切片操作，获取`list1` 第三个元素到第五个元素（包含第五个元素）。
10. 将`list1` 的第三个元素修改为两个新元素 `13, 14]`（不是列表中的一个列表，而是将两个新元素插入到指定位置）。
"""
# 1. 创建一个列表`list1`，其包含元素 1, 2, 3, 4, 5。
list1 = [1, 2, 3, 4, 5]
# 2. 向`list1` 添加一个元素 6。
list1.append(6)
# 3. 从`list1` 中删除元素 3。
list1.remove(3)
# 4. 修改`list1` 中的第二个元素值为 8。
list1[1] = 8
# 5. 找出`list1` 中值为 8 的元素索引。
index = list1.index(8)
# 6. 遍历`list1`，打印每个元素的值。
for i in list1:
    print(i)
# 7. 利用循环，将一个新列表 `[7, 8, 9]` 的每个元素添加到`list1` 的末尾。
for i in [7, 8, 9]:
    list1.append(i)
# 8. 使用一个命令，将列表 `[10, 11, 12]` 添加到`list1` 的末尾。
list1.extend([10, 11, 12])
print(list1)
# 9. 使用切片操作，获取`list1` 第三个元素到第五个元素（包含第五个元素）。
print(list1[2:5])
# 10. 将`list1` 的第三个元素修改为两个新元素 `[13,14]`（不是列表中的一个列表，而是将两个新元素插入到指定位置）。
list1[2:2] = [13, 14]
print(list1)


"""
1. 向my_list中添加一个元素"fig"。
2. 从my_list中删除元素"banana"。
3. 将元素7修改为字符串"grape"。
4. 查找并打印元素"cherry"的索引值。
5. 遍历my_list并打印每个元素。
6. 在"cherry"后面插入新元素"kiwi"。
7. 使用索引查找并打印第三个元素。
8. 使用负数索引找到并打印倒数第二个元素。
9. 使用切片操作获取第三个至第七个元素并打印结果。
10. 使用切片操作反转整个列表并打印结果。
11. 对列表中的字符串进行排序，并保留数字在原位。
12. 将my_list中的数字替换为它们对应的字符串形式（如1->'one'），不改变列表中原有的字符串。
"""
# 初始列表
my_list = [3, "apple", 9, "banana", 7, "cherry", 2, "date", 5, "elderberry"]
# 1. 向my_list中添加一个元素"fig"。
my_list.append("fig")
# 2. 从my_list中删除元素"banana"。
my_list.remove("banana")
# 3. 将元素7修改为字符串"grape"。
my_list[my_list.index(7)] = "grape"
# 4. 查找并打印元素"cherry"的索引值。
print(my_list.index("cherry"))
# 5. 遍历my_list并打印每个元素。
for i in my_list:
    print(i)
# 6. 在"cherry"后面插入新元素"kiwi"。
my_list.insert(my_list.index("cherry") + 1, "kiwi")
# 7. 使用索引查找并打印第三个元素。
print(my_list[2])
# 8. 使用负数索引找到并打印倒数第二个元素。
print(my_list[-2])
# 9. 使用切片操作获取第三个至第七个元素并打印结果。
print(my_list[2:7])
# 10. 使用切片操作反转整个列表并打印结果。
print(my_list[::-1])
# 11. 对列表中的字符串进行排序，并保留数字在原位。
string_index = []
string_list = []
for (index,key) in enumerate(my_list):
    if isinstance(key, str):
        string_index.append(index)
        string_list.append(key)
string_list.sort()
for i in range(len(string_list)):
    my_list[string_index[i]] = string_list[i]
print(my_list)
# 12. 将my_list中的数字替换为它们对应的字符串形式（如1->'one'），不改变列表中原有的字符串。
dict_num = {1: "one", 2: "two", 3: "three", 4: "four", 5: "five", 6: "six",7: "seven", 8: "eight", 9: "nine", 10: "ten"}
for i in range(len(my_list)):
    if isinstance(my_list[i], int):
        my_list[i] = dict_num[my_list[i]]
print(my_list)

"""
1. 创建一个列表包含从1到100的所有偶数。
2. 将上述列表中所有偶数替换为它们的平方。
3. 从上述列表中删除所有大于1000的数字。
4. 将列表逆序。
5. 使用切片操作取出列表中的前10个元素。
6. 将一个新列表`[101, 102, 103]`加到现有列表的末尾。
7. 计算列表中元素的平均值。
8. 找到列表中的最大值和最小值。
9. 找出列表中第一次出现的11的索引位置。
10. 用循环遍历列表，把每个数字替换为其对应的字符形式（例如：1替换为'1'）。注意使用不同类型的循环来实现。
11. 将列表中的所有元素转换成浮点数形式。
12. 找出列表中所有大于50的元素个数。
13. 在列表的第3个位置插入数字99。
14. 删除列表中的最后一个元素。
15. 使用列表推导式创建一个新列表，包含原列表中每个数字乘以2的结果。
16. 将列表分成两部分，一部分是小于等于50的数，另一部分是大于50的数。
17. 将列表转换为一个字典，其中列表元素作为键，其在列表中的索引作为值。
18. 使用`enumerate`函数遍历列表，并打印元素及其索引。
19. 从列表中随机取出一个元素。
20. 将列表保存到一个txt文件里，每个元素占一行。
"""
# 1. 创建一个列表包含从1到100的所有偶数。
my_list = []
for i in range(1, 101):
    if i % 2 == 0:
        my_list.append(i)
print(my_list)
# 2. 将上述列表中所有偶数替换为它们的平方。
for i in range(len(my_list)):
    my_list[i] = my_list[i] ** 2
print(my_list)
# 3. 从上述列表中删除所有大于1000的数字。
for i in range(len(my_list)-1,-1,-1):
    if my_list[i] > 1000:
        del my_list[i]
print(my_list)
# 4. 将列表逆序。
my_list.reverse()
print(my_list)
# 5. 使用切片操作取出列表中的前10个元素。
print(my_list[:10])
# 6. 将一个新列表`[101, 102, 103]`加到现有列表的末尾。
my_list.extend([101, 102, 103])
print(my_list)
# 7. 计算列表中元素的平均值。
print(sum(my_list) / len(my_list))
# 8. 找到列表中的最大值和最小值。
print(max(my_list))
print(min(my_list))
# 9. 找出列表中第一次出现的11的索引位置。
print(my_list.index(101))
# 10. 用循环遍历列表，把每个数字替换为其对应的字符形式（例如：1替换为'1'）。注意使用不同类型的循环来实现。
for i in range(len(my_list)):
    my_list[i] = str(my_list[i])
print(my_list)
# 11. 将列表中的所有元素转换成浮点数形式。
for i in range(len(my_list)):
    my_list[i] = float(my_list[i])
print(my_list)
# 12. 找出列表中所有大于50的元素个数。
count = 0
for i in my_list:
    if i > 50:
        count += 1
print(count)
# 13. 在列表的第3个位置插入数字99。
my_list.insert(2, 99)
print(my_list)
# 14. 删除列表中的最后一个元素。
my_list.pop()
print(my_list)
# 15. 使用列表推导式创建一个新列表，包含原列表中每个数字乘以2的结果。
new_list = [i*2 for i in my_list]
print(new_list)
# 16. 将列表分成两部分，一部分是小于等于50的数，另一部分是大于50的数。
min_list = []
max_list = []
for i in my_list:
    if i <= 50:
        min_list.append(i)
    else:
        max_list.append(i)
print(min_list, max_list)
# 17. 将列表转换为一个字典，其中列表元素作为键，其在列表中的索引作为值。
dict_list = {i: my_list.index(i) for i in my_list}
print(dict_list)
# 18. 使用`enumerate`函数遍历列表，并打印元素及其索引。
for i, j in enumerate(my_list):
    print(i, j)
# 19. 从列表中随机取出一个元素。
import random
print(random.choice(my_list))
# 20. 将列表保存到一个txt文件里，每个元素占一行。
with open("list.txt", "w") as f:
    for i in my_list:
        f.write(str(i) + "\n")